﻿using CommonModel.Model;
using System;
using System.Linq;
using System.Text;

namespace CommonModel.Util
{
    //帧头处理
    public class ParseSvr
    {

        //30W模拟调频发射机, 50W自研数字电视发射机 主动上报帧头  已调试
        public static HeaderData ByteParseToHead30Wor50W(byte[] data)
        {
            HeaderData header = new HeaderData();
            try
            {
                //IP放最前面4字节
                byte[] ip = data.Skip(0).Take(4).ToArray();
                header.Ip = TransForm.BytesToFormatIp(ip);

                //端口2字节
                byte[]  port = data.Skip(4).Take(2).ToArray();
                header.Port = TransForm.ByteToUint16BigEndian(port);

                //时间戳8位
                byte[] timestamp = data.Skip(6).Take(8).ToArray();
                header.Timestamp = TransForm.ByteToLongBigEndian(timestamp);

                //protocol
                byte[] protocol = data.Skip(14).Take(1).ToArray();
                header.Protocol = TransForm.ByteToHexStringBigEndian(protocol);

                //以下数据为原始的数据帧头信息
                //命令类型码标识，消息帧头的位置占1位, 表示数据是响应帧数据还是命令帧数据
                byte[] flag = data.Skip(15).Take(1).ToArray();
                header.Flag = TransForm.ByteToHexStringBigEndian(flag);

                byte[] secondflag = data.Skip(16).Take(1).ToArray();
                header.Secondflag = TransForm.ByteToHexStringBigEndian(secondflag);

                //台站编码
                byte[] stationcode = data.Skip(17).Take(16).ToArray();
                header.Stationcode = TransForm.GetStationCode(stationcode);

                //程序序号, 当作硬件版本
                byte[] hardware = data.Skip(33).Take(2).ToArray();
                header.Hardware = TransForm.ByteToUint16(hardware).ToString();

                //根据程序序号确定设备编码
                header.Device = GetDeviceType(header.Hardware);

                //软件版本号, 占用2字节, M在前S在后
                byte[] softwareM = data.Skip(35).Take(1).ToArray();
                byte[] softwareS = data.Skip(36).Take(1).ToArray();
                header.Software = TransForm.ByteToUint8(softwareM).ToString() + "." +TransForm.ByteToUint8(softwareS).ToString();

                //厂家名称 编号
                byte[] vendor = data.Skip(37).Take(1).ToArray();
                header.Vendor = "0x" + TransForm.ByteToHexStringBigEndian(vendor).ToLower();

                //15是采集接收时新增，23为帧头
                header.Bodysize = data.Length - 15 - 23;
                header.Bodybegin = 15 + 23;
                header.MsgType = "AutoSend";
                header.Memo = "预留";
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            return header;
        }

        //50W协议结构的发射机和水冷系统的帧头 已调试
        public static HeaderData ByteParseToHeadDigit50W(byte[] data)
        {
            HeaderData header = new HeaderData();
            try
            {
                
                //IP放最前面4字节
                byte[] ip = data.Skip(0).Take(4).ToArray();
                header.Ip = TransForm.BytesToFormatIp(ip);

                //端口2字节
                byte[] port = data.Skip(4).Take(2).ToArray();
                header.Port = TransForm.ByteToUint16BigEndian(port);

                //时间戳8位
                byte[] timestamp = data.Skip(6).Take(8).ToArray();
                header.Timestamp = TransForm.ByteToLong(timestamp);

                //protocol
                byte[] protocol = data.Skip(14).Take(1).ToArray();
                header.Protocol = TransForm.ByteToHexStringBigEndian(protocol);

                //前面15字节是附加的数据
                //以下数据为原始的数据帧头信息，帧头28字节
                //命令类型码标识，消息帧头的位置占1位, 表示数据是响应帧数据还是命令帧数据
                byte[] flag = data.Skip(15).Take(1).ToArray();
                header.Flag = TransForm.ByteToHexStringBigEndian(flag);

                // 中间还有"用户自定义编码"占17字节
                //台站编码
                byte[] stationcode = data.Skip(16).Take(17).ToArray();
                header.Stationcode = TransForm.GetStationCode(stationcode);

                // 设备类型码，占用2字节 [33 + 2 = 35]
                // 因此数据最少得大于35才能认为他是通用协议的50W发射机
                //if (data.Length > 35)
                //{
                    byte[] deviceTypeld= data.Skip(33).Take(2).ToArray();
                    string deviceType = "0x"+ TransForm.ByteToHexStringBigEndian(deviceTypeld);
                    header.Device = deviceType;
                //}
                // 设备厂家码 ，占用2字节 [35 + 2 = 37]
                //if (data.Length > 37)
                //{
                    byte[] vendorId = data.Skip(35).Take(2).ToArray();
                    string vendor = "0x"+ TransForm.ByteToHexStringBigEndian(vendorId);
                    header.Vendor = vendor;
                //}

                //硬件版本号, 占用2字节, M在前S在后
                byte[] hardwareM = data.Skip(37).Take(1).ToArray();
                byte[] hardwareS = data.Skip(38).Take(1).ToArray();
                header.Hardware = TransForm.ByteToUint8(hardwareM).ToString() + "." + TransForm.ByteToUint8(hardwareS).ToString();

                //软件版本号, 占用2字节, M在前S在后
                byte[] softwareM = data.Skip(39).Take(1).ToArray();
                byte[] softwareS = data.Skip(40).Take(1).ToArray();
                header.Software = TransForm.ByteToUint8(softwareM).ToString() + "." + TransForm.ByteToUint8(softwareS).ToString();

                // 协议版本号, 占用1字节, 协议规范1.07版本后才开始有
                byte[] protoVerByte = data.Skip(41).Take(1).ToArray();
                header.Transmit = TransForm.ByteToUint8(protoVerByte).ToString();

                //预留, 占用1字节, 协议规范1.07版本后才开始有
                byte[] memoByte = data.Skip(42).Take(1).ToArray();
                header.Memo = "预留";

                //以下是帧体
                //设备ID, 占用1字节, 协议规范1.07版本后才开始有
                byte[] deviceID = data.Skip(43).Take(1).ToArray();

                //15是采集接收时新增，28为帧头
                header.Bodysize = data.Length - 43;
                header.Bodybegin = 43;
                
                //设备类型消息，取到了帧体部分
                byte[] functionCodeBytes = data.Skip(44).Take(1).ToArray();
                String functionCode =TransForm.ByteToHexString(functionCodeBytes);
                switch (functionCode)
                {
                    case "0x03":
                        header.MsgType="GetDevMsg";
                        break;
                    case "0x65":
                        header.MsgType = "AutoSend";// 主动上报
                        break;
                    case "0x66":
                        header.MsgType = "AlarmAutoMsg";
                        break;
                    case "0x56":
                        header.MsgType = "HeartbeatMsg";
                        break;
                    default:
                        break;
                }

            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            return header;
        }

        //4级台站电源复位器和环境采集器无帧头 已调试
        public static HeaderData ByteParseToHead_NoHeader(byte[] data)
        {
            HeaderData header = new HeaderData();
            try
            {
                //IP放最前面4字节
                byte[] ip = data.Skip(0).Take(4).ToArray();
                header.Ip = TransForm.BytesToFormatIp(ip);

                //端口2字节
                byte[] port = data.Skip(4).Take(2).ToArray();
                header.Port = TransForm.ByteToUint16BigEndian(port);

                //时间戳8位
                byte[] timestamp = data.Skip(6).Take(8).ToArray();
                header.Timestamp = TransForm.ByteToLong(timestamp);

                //protocol
                byte[] protocol = data.Skip(14).Take(1).ToArray();
                header.Protocol = TransForm.ByteToHexStringBigEndian(protocol);

                // 以下数据为自定义的数据帧头信息（从帧体中读取）
                //命令类型码标识，测试数据中第一字节是00
                byte[] flag = data.Skip(16).Take(1).ToArray();
                header.Flag = TransForm.ByteToHexStringBigEndian(flag);

                //台站编码
                byte[] stationcode = data.Skip(17).Take(16).ToArray();
                header.Stationcode = TransForm.GetStationCode(stationcode);

                // 程序序号, 当作硬件版本
                byte[] hdwareBytes = data.Skip(33).Take(2).ToArray();
                header.Hardware = TransForm.ByteToUint16(hdwareBytes).ToString();

                //软件版本号, 占用2字节, M在前S在后
                byte[] softwareM = data.Skip(35).Take(1).ToArray();
                byte[] softwareS = data.Skip(36).Take(1).ToArray();
                header.Software = TransForm.ByteToUint8(softwareM).ToString() + "." + TransForm.ByteToUint8(softwareS).ToString();

                //厂家名称
                byte[] vendorNameBytes = data.Skip(37).Take(2).ToArray();
                header.Vendor= TransForm.ByteToHexString(vendorNameBytes);

                //采集器地址
                byte[] addressBytes= data.Skip(39).Take(1).ToArray();
                string address = TransForm.ByteToHexString(addressBytes);

                //功能码
                byte[] funcNameBytes = data.Skip(40).Take(1).ToArray();
                string funcName = TransForm.ByteToHexString(funcNameBytes);
                if ("0x61".Equals(funcName))
                {
                    //环境采集器主动上报类型
                    header.MsgType="AutoSend";
                }
                else if ("0x3d".Equals(funcName))
                {
                    //环境采集器读告警状态数据类型
                    header.MsgType = "AlarmSend";
                }
                else if ("0x3e".Equals(funcName))
                {
                    //环境采集器读温度参数控制
                    header.MsgType = "TemperatureSend";
                }
                else if ("0x3f".Equals(funcName))
                {
                    //环境采集器读设置时间命令
                    header.MsgType = "GetBrocastSchedule";
                }
                else if ("0x40".Equals(funcName))
                {
                    //环境采集器读内部逻辑总开关状态命令
                    header.MsgType = "SwitchStateSend";
                }
                else if ("0x41".Equals(funcName))
                {
                    //环境采集器 读IP地址、端口和发送间隔时间
                    header.MsgType = "AddressPortSendTime";
                }
                else if ("0x49".Equals(funcName))
                {
                    //环境采集器读卡号和密码信息
                    header.MsgType = "AccountPassWdConfig";
                }
                else
                {
                    //其他
                    header.MsgType = "StatusAutoMsg";
                }

                // 电源复位器设备类型码
                if ((header.Flag).Equals("46"))
                {
                    header.Device = "0x1201";
                }

                // 环境采集器设备类型码
                if ((header.Flag).Equals("43")) 
                {
                    header.Device = "0x0E02";
                }

                //预留
                header.Memo = "";

                //15是采集接收时新增，41为帧头
                header.Bodysize = data.Length - 15 - 41;
                header.Bodybegin = 15 + 41;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            return header;
        }

        //30W模拟调频发射机, 50W自研数字电视发射机，设置参数上报帧头
        public static HeaderData ByteParseToHeadConfig30Wor50W(byte[] data)
        {
            HeaderData header = new HeaderData();
            return header;
        }

        //主控程序（远程监控通信协议）帧头 已调试
        public static HeaderData ByteParseToHeadGxgd(byte[] data)
        {
            HeaderData header = new HeaderData();
            try
            {
                //IP放最前面4字节
                byte[] ip = data.Skip(0).Take(4).ToArray();
                header.Ip = TransForm.BytesToFormatIp(ip);

                //端口2字节
                byte[] port = data.Skip(4).Take(2).ToArray();
                header.Port = TransForm.ByteToUint16BigEndian(port);

                //时间戳8位
                byte[] timestamp = data.Skip(6).Take(8).ToArray();
                header.Timestamp = TransForm.ByteToLong(timestamp);

                //protocol
                byte[] protocol = data.Skip(14).Take(1).ToArray();
                header.Protocol = TransForm.ByteToHexStringBigEndian(protocol);

                //以下数据为原始的数据帧头信息
                //命令类型码标识，测试数据中第一字节是00
                byte[] flag = data.Skip(15).Take(1).ToArray();
                header.Flag = TransForm.ByteToHexStringBigEndian(flag);

                //帧体总长
                byte[] len= data.Skip(16).Take(2).ToArray();

                //厂家名称 ,5个汉字
                byte[] vendor = data.Skip(18).Take(11).ToArray();
                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);//在使用编码方法（Encoding.GetEncoding("GB2312")）之前，对编码进行注册
                string str = Encoding.GetEncoding(TransForm.encode).GetString(vendor, 0, vendor.Length).ToString();
                str = str.Replace("\0", "");
                header.Vendor = str;

                //设备类型码
                byte[] deviceTypeBytes = data.Skip(29).Take(2).ToArray();
                header.Device = TransForm.ByteToHexString(deviceTypeBytes);

                //硬件版本号, 占用2字节, S在前M在后
                byte[] hardwareM = data.Skip(31).Take(1).ToArray();
                byte[] hardwareS = data.Skip(32).Take(1).ToArray();
                header.Hardware = TransForm.ByteToUint8(hardwareS).ToString() + "." + TransForm.ByteToUint8(hardwareM).ToString();

                //软件版本号, 占用2字节, S在前M在后
                byte[] softwareM = data.Skip(33).Take(1).ToArray();
                byte[] softwareS = data.Skip(34).Take(1).ToArray();
                header.Software = TransForm.ByteToUint8(softwareS).ToString() + "." + TransForm.ByteToUint8(softwareM).ToString();

                // 设备地址（主版本或高位）
                byte[] devAddrBytes = data.Skip(34).Take(2).ToArray();
                int devAddr = TransForm.ByteToUint16(devAddrBytes);
                if (devAddr > 1000)
                {
                    header.Devaddr=devAddr;
                }
                else
                {
                    header.Devaddr= header.Port;
                }

                //预留，5个字节
                byte[] reserve = data.Skip(35).Take(5).ToArray();
                header.Memo = TransForm.ByteToString(reserve);

                //15是采集接收时新增，25为帧头
                header.Bodysize = data.Length - 15 -25;
                header.Bodybegin = 15 + 25;

                if (header.Bodysize <= 2)
                {// 有些包里会包含不是正确数据包的数据，长度比正常的数据短，因此要屏蔽掉 ldc 2020/08/26
                    header.ErrorFlag="yes";
                }
                else
                { //帧头总共15+25=40,StationCode 18 字节,40+18=58
                    //Command, 占 21 字节
                    byte[] commandbytes = data.Skip(58).Take(21).ToArray();
                    string msgType = Encoding.UTF8.GetString(commandbytes, 0, commandbytes.Length).ToString();
                    msgType = msgType.Replace("\0", "");
                    header.MsgType=msgType;
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            return header;
        }

        //300/1000W 数字电视发射机主动上报消息头
        public static HeaderData ByteParseToHeadDigitTransmitter300(byte[] data)
        {
            HeaderData header = new HeaderData();
            try
            {
                //IP放最前面4字节
                byte[] ip = data.Skip(0).Take(4).ToArray();
                header.Ip = TransForm.BytesToFormatIp(ip);

                //端口2字节
                byte[] port = data.Skip(4).Take(2).ToArray();
                header.Port = TransForm.ByteToUint16BigEndian(port);

                //时间戳8位
                byte[] timestamp = data.Skip(6).Take(8).ToArray();
                header.Timestamp = TransForm.ByteToLong(timestamp);

                //protocol
                byte[] protocol = data.Skip(14).Take(1).ToArray();
                header.Protocol = TransForm.ByteToHexStringBigEndian(protocol);

                // 以下数据为原始的数据帧头信息
                // 起始字、设备地址、指令码、数据长度
                // 命令类型码标识，消息帧头的位置占1位, 表示数据是响应帧数据还是命令帧数据
                byte[] flag = data.Skip(15).Take(1).ToArray();
                header.Flag = TransForm.ByteToHexStringBigEndian(flag);

                // 设备地址，消息帧头的位置占1位, 获得该信息后重新赋值 port
                byte[] devAddrBytes = data.Skip(16).Take(1).ToArray();
                int devAddr = (devAddrBytes[0] & 0xFF);
                header.Devaddr = devAddr;
                header.Port = 2000 + devAddr;
                //指令码 data.Skip(17).Take(1).ToArray();
                //数据长度
                byte[] len = data.Skip(18).Take(2).ToArray();
                header.Bodysize = TransForm.ByteToUint16(len);

                header.Bodybegin = 15;
                // 台站编码, 设备类型码, 设备厂家码, 硬件版本号, 软件版本号, 协议版本号, 预留字段 等信息都在消息体中才能获取
                header.Memo="300/1000";
                header.MsgType="AutoSend";

                //以下信息从帧体中获取
                //设备类型码（发射机类型）
                byte[] device = data.Skip(40).Take(1).ToArray();
                header.Device = TransForm.ByteToHexString(device);

                //生产厂家，前15附加的信息，厂家前面有29
                byte[] vendor = data.Skip(44).Take(40).ToArray();
                header.Vendor = TransForm.ByteToStringUTF8(vendor);
                header.Vendor = header.Vendor.Replace("\r","");

                /**
			     * 增加帧体的解析, 获取 设备类型0x0101 字段信息, 作为设备类型码的标记<br/>
			     * 帧体前共5字节<br/>
			     * 采集模块附加 15 字节, 帧头 5 字节, 共 20 字节, 设备类型0x0101 占1字节，前面有67个字节<br/>
			     * 20 + 67 = 87
			     */
                //设备类型
                byte[] devibytes = data.Skip(87).Take(1).ToArray();
                header.DeviceType = TransForm.ByteToHexString(devibytes);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            return header;
        }

        /*
         * 根据软件序号判断生成设备类型码
         * 返回设备类型码。 设备类型码由用户定制，用于判断该设备是什么设备类型
         */
        private static string GetDeviceType(string softSeq)
        {
            switch (softSeq)
            {
                case "1005":
                    return "0x0301";
                case "1006":
                    return "0x0301";
                case "1020":
                    return "0x0201";
                case "1021":
                    return "0x0201";
                case "2001":
                    return "0x0707";
                case "2002":
                    return "0x0707";
                case "2011":
                    return "0x0708";
                case "1030":
                    return "0x0801";
                case "1031":
                    return "0x0801";
                default:
                    return "0x0000";
            }
        }

        /**
	     * 将消息头装饰成统一格式<br/>
	     * 1. 重新赋值“设备类型”， “厂家”， “软硬件版本”<br/>
	     * 2.软硬件版本为空时，默认为"1.0"
	     * @param header
	     */
        public static void DecorateHead(HeaderData header)
        {
            try
            {
                // 远程监控设备通信协议的消息头
                if (header.Flag.Equals("3c"))
                {

                    if (header.Device.Equals("0x8020"))
                    {
                        /**
                         * 1-3级台站1000W模拟调频电视1+1控制器
                         */
                        header.Device="0x0701";
                    }

                    if (header.Device.Equals("0x8021"))
                    {
                        /**
                         * 1-3级台站300W模拟调频电视1+1控制器
                         * 
                         * @author ldc 2020/7/7
                         */
                        header.Device="0x0702";
                    }

                    if (header.Device.Equals("0x8022"))
                    {
                        /**
                         * 1-3级台站1000W模拟调频N+1控制器
                         * 
                         * @author ldc 2020/7/8
                         */
                        header.Device="0x0703";
                    }

                    if (header.Device.Equals("0x8023"))
                    {
                        /**
                         * 1-3级台站300W模拟调频N+1控制器
                         * 
                         * @author ldc 2020/7/8
                         */
                        header.Device="0x0704";
                    }

                    if (header.Device.Equals("0x8040"))
                    {
                        /**
                         * 1-2级台站中波1+1控制器
                         * 
                         * @author ldc 2020/7/8
                         */
                        header.Device="0x0705";
                    }

                    if (header.Device.Equals("0x8050"))
                    {
                        /**
                         * 1-3级台站电力软件控制器
                         * 
                         * @author ldc 2020/7/8
                         */
                        header.Device="0x0B01";
                    }

                    if (header.Device.Equals("0x8070"))
                    {
                        /**
                         * 1-3级台站环境系统软件控制器
                         * 
                         * @author ldc 2020/7/8
                         */
                        header.Device="0x0E01";
                    }

                    if (header.Device.Equals("0x8010"))
                    {
                         //模拟信号源软件控制器
                        header.Device="0x0101";
                    }

                    if (header.Device.Equals("0x0080"))
                    {
                        /**
                         * 1-3级站点 远场6路
                         * 
                         * @author ldc 2020/6/30
                         */
                        header.Device="0x0901";
                    }
                }
                /**
                 * 通用协议 命令标识码为0x25（%为设备响应）
                 */
                else if (header.Flag.Equals("25"))
                {
                    /**
                     * 30W模拟调频发射机 30W主备切换器 30W转频器模块 50W自研数字 50W主备切换器
                     */
                    if (header.Secondflag!= null && header.Secondflag.Equals("5a"))
                    {
                        resetDevice_30Wor50W(header);
                    }
                    else if (header.Device.Equals("0x0009"))
                    {// 设备类型
                        /**
                         * 通用协议 V1.06 蓝拓扑 IP码流分析仪 通用协议 V1.06 蓝拓扑 IP码流比对仪
                         */
                        if (header.Vendor.Equals("0x0025"))
                        {// 厂家编号
                            resetDevice_0x0025_LanTuoPu(header);
                        }

                        /**
                         * 通用协议 V1.07 DTMB接收机-北京博汇 通用协议 V1.02 DTMB接收机-上海高清 500型
                         */
                        else if (header.Vendor.Equals("0x0024"))
                        {// 厂家编号
                            resetDevice_0x0024(header);
                        }
                    }

                    /**
                     * 通用协议 V1.04 DTMB 50W发射机 即50W地面数字电视广播发射机(=四级台站的数字电视发射机)
                     * 
                     * @author H 2020/6/8
                     */
                    else if (header.Device.Equals("0x0003"))
                    {
                        header.Device="0x0302"; // 50W地面数字电视广播发射机 
                    }
                    /**
                     * 通用协议 V1.07 28位 8通道IP解码器-高斯贝尔
                     * 
                     * @author H 2020/6/15
                     */
                    else if (header.Device.Equals("0x000B"))
                    {
                        header.Device="0x0401"; 
                    }

                    /**
                     * 通用协议 V1.02 DTMB接收机-上海高清 600型
                     * 
                     * @author H 2020/6/15
                     */
                    else if (header.Device.Equals("0x000A"))
                    {
                        header.Device="0x0902"; 
                        header.Vendor="0x0026";
                    }

                }

                /**
                 * 中央300W/1000W通信协议 旧的300W/1000W的设备类型是0x09---根据文档可知此0x09是预留的
                 */
                if (header.Flag.Equals("aa") && header.Device.Equals("09"))
                {
                    header.Device="0x0303";
                    header.Vendor="0x0006";// 成都德芯
                    header.Hardware="1.0";
                    header.Software="1.0";
                }

            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        /**
         * 功能：根据硬件版本号重新赋值设备类型码</br>
         * 解析对象: 30W模拟调频发射机 </br>
         * 30W主备切换器</br>
         * 30W转频器模块</br>
         * 50W自研数字</br>
         * 50W主备切换器</br>
         */
        public static void resetDevice_30Wor50W(HeaderData header)
        {
            string hardWareVersion = header.Hardware;

            switch (hardWareVersion)
            {
                case "1005":// 50W自研数字
                    header.Device="0x0301";
                    header.Vendor="0x0000";
                    break;
                case "1006":
                    header.Device="0x0301";
                    header.Vendor="0x0000";
                    break;
                case "1020":// 30W模拟调频
                    header.Device="0x0201";
                    break;
                case "1021":
                    header.Device="0x0201";
                    break;
                case "2001":// 30W主备切换器
                    header.Device="0x0707";
                    break;
                case "2002":
                    header.Device="0x0707";
                    break;
                case "2011":// 50W主备切换器
                    header.Device="0x0081_50W_SW";
                    break;
                case "2012":
                    header.Device="0x0081_50W_SW";
                    break;
                case "1030":// 30W转频器模块，无XML文件?
                    header.Device="0x0801";
                    break;
                case "1031":
                    header.Device="0x0801";
                    break;
                default:
                    break;
            }
        }

        /**
         * 功能：根据硬件版本号重新赋值设备类型码</br>
         * 前提条件：同一厂家编号 不同硬件版本</br>
         * 解析对象：通用协议 蓝拓扑IP码流分析仪+</br>
         * 通用协议 蓝拓扑IP码流比对仪+</br>
         * 转码卡已下线 2020/07/09 厂家编号： 0x0025
         */
        public static void resetDevice_0x0025_LanTuoPu(HeaderData header)
        {
            // 硬件版本号
            String hardWareVersion = header.Hardware;

            // 消息类型 主动上报
            switch (hardWareVersion)
            {
                case "1.0":// IP码流分析仪
                    header.Device="0x1002";
                    break;
                case "1.2":// IP码流比对仪
                    header.Device="0x1001"; 
                    break;
                default:
                    break;
            }
        }

        /**
         * 功能：根据硬件版本号重新赋值设备类型码,修改错误的厂家编号</br>
         * 前提条件：同一厂家编号 不同硬件版本</br>
         * 解析对象：通用协议 /V1.07/DTMB接收机-北京博汇 </br>
         * 通用协议 V1.02 DTMB接收机-上海高清 500型</br>
         * 转码卡已下线 -2020/07/09 厂家编号： 0x0024
         */
        public static void resetDevice_0x0024(HeaderData header)
        {
            // 硬件版本号
            String hardWareVersion = header.Hardware;

            switch (hardWareVersion)
            {
                case "1.4":// DTMB接收机-北京博汇
                    header.Device="0x0902";
                    break;
                case "1.1":// DTMB接收机-上海高清 500型
                    header.Device="0x0902";
                    header.Vendor="0x0026";// 厂家编号
                    break;
                default:
                    break;
            }

        }

    
    }


}
